public V get(Object key) {
    	//如果key是null的话，调用getForNullKey方法
        if (key == null)
            return getForNullKey();
    	//调用getEntry方法获取相应的Entry
        Entry<K,V> entry = getEntry(key);
		//如果Entry为null，说明map中不存在这个键，返回null，否则返回Entry中的value
        return null == entry ? null : entry.getValue();
    }
<!-- more --> 
//获取空键的值的方法
private V getForNullKey() {
    	//如果当前容量为0，则返回null
        if (size == 0) {
            return null;
        }
    	//遍历数组第一个位置上的bucket中的链表，找到当前键为空的Entry的值返回
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }
//获取Entry的方法
final Entry<K,V> getEntry(Object key) {
    	//如果当前容量为0，则返回null
        if (size == 0) {
            return null;
        }
		//调用hash方法算出key的hash值
        int hash = (key == null) ? 0 : hash(key);
    	//调用indexFor方法找到key所在位置的bucket，遍历当前bucket中的链表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
           //如果key相同，则返回
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

//直接调用getEntry方法，如果不返回空的话就存在
public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

public boolean containsValue(Object value) {
    	//如果指定value是null的话，调用containsNullValue取值
        if (value == null)
            return containsNullValue();
		//和containsNullValue方法一样，先遍历table后遍历链表
        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))
                    return true;
        return false;
    }

private boolean containsNullValue() {
    	//遍历table
        Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            //遍历table上每个bucket中的链表，有null值则返回true
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (e.value == null)
                    return true;
        return false;
    }

public V remove(Object key) {
    	//调用removeEntryForKey方法移除key所在的Entry并返回
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

final Entry<K,V> removeEntryForKey(Object key) {
        if (size == 0) {
            return null;
        }
    	//老套路，算hash值
        int hash = (key == null) ? 0 : hash(key);
    	//计算索引
        int i = indexFor(hash, table.length);
    	//得到该索引上的Entry
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;
		//遍历该位置上的链表
        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            //找key
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                //操作次数加一
                modCount++;
                //当前容减一
                size--;
                //如果第一个Entry就是要删除的key所在的
                if (prev == e)
                    //该位置上的首节点变为被删除的节点的下一节点[把下一个节点网上顶！否则删除了就没有						//了]
                    table[i] = next;
                else
                    //如果不是的话将上一节点指向下一节点[链表的删除]
                    prev.next = next;
                //这个是Entry被删除的时候调用的，是个空实现
                e.recordRemoval(this);
                return e;
            }
            //往下遍历
            prev = e;
            e = next;
        }

        return e;
    }

public void clear() {
    	//操作次数加1
        modCount++;
    	//调用Arrays.fill将HashMap中的table数组上的每个元素都置空
        Arrays.fill(table, null);
    	//当前容量置0
        size = 0;
    }

public Hashtable() {
        this(11, 0.75f);
    }

 protected void rehash() {
        int oldCapacity = table.length;
        Entry<K,V>[] oldMap = table;

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    static final long serialVersionUID = -5024744406713321676L;

    private transient HashMap<E,Object> map;